

#include "listeCarte.h"
#include <malloc.h>

Pioche * creerPioche()
{
    Pioche * P = (Pioche*)malloc(1 * sizeof(Pioche));
    initPioche(P);
    return P;
}

void initPioche(Pioche * P)
{
    P->debut = NULL;
    P->fin = NULL;
}

Cellule * creerCellule()
{
    Cellule * C = (Cellule*)malloc(1 * sizeof(Cellule));
    initCellule(C);
    return C;
}

void initCellule(Cellule * C)
{
    C->contenu = creerCarte();
    C->suivant = NULL;
    C->preced = NULL;
}

void enfilerCarte (Pioche * P, const Carte * carte)
{
    Cellule * c = creerCellule();
    copieCarte(c->contenu,carte);
    c->suivant = NULL;

	if(P->fin == NULL)
    {
        c->preced = NULL;
        P->debut = c;
    }
	else
	{
	    c->preced = P->fin;
	    P->fin->suivant = c;
	}

	P->fin = c;
}

void defilerRenfilerCarte (Pioche *pioche)
{
	/** Le 1er élément pointe sur le dernier, et inversement*/    
	pioche->debut->preced = pioche->fin;
	    pioche->fin->suivant = pioche->debut;

	/** La sentinelle pointe sur le nouveau dernier élément (anciennement 1er)*/
    	pioche->fin = pioche->debut;
	/** La sentinelle pointe sur le nouveau 1er élément (anciennement 2ème)*/
    	pioche->debut = pioche->debut->suivant;

    	pioche->debut->preced = NULL;
    	pioche->fin->suivant = NULL;
}

void retourneTetePioche(const Pioche * pio, Carte * c)
{
    strcpy(c->nom, getNomCarte(pio->debut->contenu));
    strcpy(c->definition,  getDefinitionCarte(pio->debut->contenu));
    c->genre = getGenreCarte(pio->debut->contenu);
}

void testamentPioche(Pioche * pioche)
{
	Cellule * c;
	while (pioche->debut!=NULL)
	{
		c = pioche->debut;
		pioche->debut = pioche->debut->suivant ;
		detruireCellule(&c);
		free(c);
	}
}

void detruirePioche(Pioche ** P)
{
    testamentPioche(*P);
    free(*P);
    *P = NULL;
}

void libereCellule(Cellule * C)
{
    detruireCarte(&C->contenu);
    C->suivant = NULL;
    C->preced = NULL;
}

void detruireCellule(Cellule ** C)
{
    libereCellule(*C);
    free(*C);
    *C = NULL;
}

void remplirPiocheListeTC(ListeTempC * ListeTC, Pioche * pioche)
{
    int i,j,l;
    int nbralea;

    Carte * C;

    i = nbrElementListeC(ListeTC);
    l = i;

    initNbrAlea2();
    for(j=0;j<i;j++)
    {
        nbralea = nbrAleatoire2(l);
        C = creerCarte();
        copieCarte(C,&ListeTC->tab[nbralea]);
        enfilerCarte(pioche,C);
        detruireCarte(&C);
        supprimerElementListeC(ListeTC,nbralea);
        l = nbrElementListeC(ListeTC);
    }
    detruireListeTempC(&ListeTC);
}

void testRegressionListeCarte()
{
    printf("** Test regression : Pioche **\n");
    int i;
    char *ligne1;
	ligne1 = "Carte1";
    char *ligne2;
	ligne2 = "Carte2";
    char *ligne3;
	ligne3 = "Carte3";
    char *ligne4;
	ligne4 = "Carte4";
	
	/** On initialise la pioche et les cartes*/
    Pioche * pio;
	pio = creerPioche();
    Carte * C1;
	C1 = creerCarte();
    Carte * C2;
	C2 = creerCarte();
    Carte * C3;
	C3 = creerCarte();
	/** On rempli les cartes*/
    setNomCarte(C1, ligne1);
    setNomCarte(C2, ligne2);
    assert(C1->nom != NULL);
    assert(C2->nom != NULL);
    printf("* Cartes remplies *\n");
	/** On rempli la pioche*/
    enfilerCarte(pio, C1);
    enfilerCarte(pio, C2);
    setNomCarte(C1, ligne3);
    setNomCarte(C2, ligne4);
    enfilerCarte(pio, C1);
    enfilerCarte(pio, C2);
    assert(pio->debut != NULL);
    assert(pio->fin != NULL);
    assert(pio->debut != pio->fin);
    printf("* Pioche remplie *\n");
	/** On fait défiler les cartes contenues dans la pioche*/
    printf("* Défilement des cartes dans la pioche : *\n");
    for(i=0;i<4;i++)
    {
        printf(" -> %s\n", getNomCarte(pio->debut->contenu));
        defilerRenfilerCarte(pio);
    }

	/** Test de la fonction retourneTetePioche*/
    retourneTetePioche(pio,C3);
    assert(C3->nom != NULL);
    printf("* Contenu de la carte en tête de pioche récuperé *\n");
	/** On libère la pioche (libération de C1 et C2) et de C3*/
    detruirePioche(&pio);
    detruireCarte(&C1);
    detruireCarte(&C2);
    detruireCarte(&C3);
    printf("** Testament de la pioche : Okay **\n\n");

}
